"""
内置函数：
这些内置函数可以直接使用, 不需要执行任何模块的导入.

但是, 大家也要清楚这些内置函数都是定义在内置的模块:builtins中.

id()   # 打印一个对象的内存地址
type() # 查看一个对象的类型
isinstance() # 两个参数,(对象,类)  B(A)  b
issubclass()

ord(char),字符转编码
chr(code), 编码转字符

abs(),
pow(a,b),
sum(),求和
enumerate() # 遍历容器加个角标
all(iterable),判断可迭代对象中所有的元素都是True，或者相当于True。
    and
any(iterable)，判断有一个是true或者相当于True
    or

进制：
    二进制：0,1
    八进制：0,1,2,3,4,5,6,7
    十进制：0,1,2,3,4,5,6,7,8,9
    十六进制：0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F

bin(),二进制
int()，十进制
oct(),八进制
hex(),十六进制



dir(),显示对象能够访问的属性
delattr(obj,attrname),删除对象的属性
    同del obj.attrname
hasattr(obj,attrname),判断是否含有某个属性

divmod(a, b),返回一个元素(取商，取余)

help()





内置的高阶函数
sorted()
map()
reduce()
filter()
"""

print(isinstance(2, int))
print(isinstance(False, bool))

print(isinstance(False, int))

print(issubclass(bool, int))

# 前边这个类是否属于 后边这个元组中的其中一种类型
print(issubclass(bool, (float, str)))
print(issubclass(bool, (int, str)))

print(ord('A'))
print(chr(65))

print(2 ** 4)
print(pow(2, 4))

print(sum([1, 2]))

dict1 = {'a': 3, 'b': 4}
print(sum(dict1.values()))
dict2 = {1: 8, 2: 9}
print(sum(dict2))
print('ssssssssssssssssssssss')
for i in dict2:
    print(i)
for i in dict2.keys():
    print(i)
for i in dict2.values():
    print(i)
for k, v in dict2.items():
    print('k-->', k)
    print('v-->', v)

list1 = [1, 3, 5, 7, 9]

for i in list1:
    print(i)
# for i in enumerate(list1):
#     print(i)
for index, value in enumerate(list1):
    print('index:', index)
    print(value)

for k, v in enumerate(dict2.values()):
    print('k---->', k)
    print('v---->', v)

list2 = [2, None, [], 4.5, {}]
list3 = [2, [2, 3], 4.5, {6, 8}]
print(all(list2))
print(all(list3))

# python 看见空的容器 或者 None, False 都是 False
print(bool({}))
"""
在其他语言中判空
if len(list2) == 0:
    pass
python中判空
if list2:
    pass

"""
print(all([]))
list2 = [2, None, [], 4.5, {}]
list3 = [2, [2, 3], 4.5, {6, 8}]
list4 = [{}, [], None, False, ()]
print('--------any----or----')
print(any(list2))
print(any(list3))
print(any(list4))

print('-----bin-----oct----int----hex---------------------')

print(20)
print(bin(20))
print(oct(20))
print(hex(20))

print(hex(20) == bin(20))  # False


class A:
    def __init__(self, name):
        self.name = name

    def fun1(self):
        print('fun1---')


class B(A):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def fun2(self):
        print('fun2---')


o = object()

a = A('andy')
b = B('boby', 18)
print(dir(a))
print(dir(b))
print(dir(o))
print(hasattr(b, 'age'))
print(hasattr(b, 'name'))
print(hasattr(a, 'age'))
print('--------delattr----------')
delattr(b, 'age')
print(hasattr(b, 'age'))
print(dir(b))

print(divmod(5, 3))  # Return the tuple (x//y, x%y).  Invariant: div*y + mod == x.
# import time
# time.time()
# help(time)

# sorted()
# map()
# filter()

# 直接在原数据上修改了
list5 = [3, 9, 5, 8, 7]
list5.sort()
print(list5)

# 对源数据没影响
list6 = [3, 9, 5, 8, 7]
newlist = sorted(list6)
print('newlist:', newlist)
print(list6)

m1 = map(lambda x: x ** 2, list6)
print(type(m1))
print(m1)
print(list(m1))
list7 = [3, 9, 2, 5, 7, 19, 10]
# 参数的个数和迭代对象的个数相同,迭代器的长度以短的为准
m1 = map(lambda x, y: x + y, list6, list7)
print(type(m1))
print(m1)
print(list(m1))

f1 = filter(lambda x: x % 2 == 1, list7)
print(list(f1))
f2 = filter(lambda x: x>5, list7)
print(f2)
print(type(f2))
print(list(f2))